第26条 不要在分类中声明属性

属性是封装数据的方式(参见第6条)。尽管从技术上说,分类里也可以声明属性,但这种做法还是要尽量避免。

原因在于,除了“class-continuation分类”(参见第27条)之外,其他分类都无法向类中新增实例变量,因此,它们无法把实现属性所需的实例变量合成出来。如果我们在分类中声明了一个friends属性。会提示我们

warning: property 'friends' requires method 'friends' to be defined - use @dynamic or provide a method implementation in this category [-Wobjc-property-implementation]

warning: property 'friends' requires method 'setFriends:' to be defined - use @dynamic or provide a method implementation in this category [-Wobjc-property-implementation]

说明系统没有为我们自动合成属性的setget方法。我们要自己在分类中去实现,可以把存取方法声明为@dynamic, 也就是说,这些方法等到运行期再提供,编译器目前是看不见的。如果决定使用消息转发机制(参见第12条)在运行期拦截方法调用,并提供其实现,那么或许可以采用这种做法。

当然我们也可以使用关联对象的方法。但是还是不建议我们在分类中定义封装数据的属性。

正确做法是把所有属性都定义在主接口里。类所封装的全部数据都应该定义在主接口中,这里是唯一能够定义实例变量(也就是数据)的地方。而属性只是定义实例变量及相关存取方法所用的“语法糖”,所以也应遵循同实例变量一样的规则。至于分类机制,则应将其理解为一种手段,目标在于扩展类的功能,而非封装数据。

但是有时候,只读属性(readonly)可以在分类中使用,但是我们要手动实现它的get方法。当然我们不建议搞特殊。最好还是在主接口中声明。然后在分类中声明一个获取方法,来获取数据。

要点

  • 把封装数据所用的全部属性都定义在主接口里。
  • “class-contimiation分类”之外的其他分类中,可以定义存取方法,但尽量不要定义属性。
2017/9/1 posted in  第四章 协议与分类

第25条 总是为第三方类的分类名称加前缀

分类机制通常用于向无源码的既有类中新增功能。这个特性极为强大,但在使用时也很容易忽视其中可能产生的问题。

我们在分类中添加方法,系统在运行期时会将分类中的方法加入类中。运行期系统会把分类中所实现的每个方法都加入类的方法列表中。如果类中本来就有此方法,而分类又实现了一次,那么分类中的方法会覆盖原来那一份实现代码。实际上可能会发生很多次榭盖,比如某个分类中的方法覆盖了“主实现”中的相关方法,而另外一个分类 中的方法又覆盖了这个分类中的方法。多次覆盖的结果以最后一个分类为准。

所以我们为了解决此问题,一般做法是:以命名空间来区别各个分类的名称与其中所定义的方法。我们这里的命名空间只是在相关名称前都加上公用的前缀。

所以我们举例来说就是这样的:

@interface NSString (ABC_HTTP)
//Encode a string with URL encoding 
-(NSString*) abc_urlEncodedStiring;

// Decode a URL ©ncodeci string
-(NSString*) abc_urlDecodedString;
@end

要点

  • 向第三方类中添加分类时,总应给其名称加上你专用的前缀。
  • 向第三方类中添加分类时,总应给其中的方法名加上你专用的前缀。
2017/9/1 posted in  第四章 协议与分类

第24条 将类的实现代码分散到便于管理的数个分类之中

一个类里面经常会填满各种各样的方法,有时候将那么多方法放在一个类的实现文件里是合理的。但是我们如果通过OC的分类机制将类代码按逻辑划入几个分区中,这对于开发和调试都有帮助。

我们来举个例子,我们对个人信息建模分类:

#import <Foundation/Foundation.h>
Sinterface EOCPerson : NSObject
@property (nonatomic, copy, readonly) NSString *firstName; 
@property (nonatomic, copy, readonly) NSString *lastName; 
@property (nonatomic, strong, readonly) NSArray *friends;

-(id)initWithFirstName:(NSString*) firstName
            andLastName:(NSString*)lastName;
            
/* Friendship methods */
-(void)addFriend:(EOCPerson*)person;
- (void)removeFriend:(EOCPerson*)person;
-(BOOL)isFriendsWith:(EOCPerson*)person;

/* Work methods */
-(void)performDaysWork;
-(void)takeVacationFromWork;

/* Play methods */
-(void)goToTheCinema;
-(void)goToSportsGame;

在实现该类时,所有方法的代码可能会写在一个大文件里。显得很臃肿。所以可以用“分类”机制把刚才的类改写成下面这样:

@import <Foundation/Foundation.h>
@interface EOCPerson : NSObject
@property (nonatomic, strong, readonly) NSArray *friends;
@property (nonatomic, copy, readonly) NSString *lastName;
@property (nonatomic, copy, readonly) NSString *firstName; 
 
-(id) initWithFirstName: (NSString*)firstName
            andLastNames:(NSString*)lastName;

@end

@interface EOCPerson (Friendship)
-(void)addFriend:(EOCPerson*)person;
-(void)removeFriend:(EOCPerson*)person;
-(BOOL)isFriendsWith:(EOCPerson*)person; 
@end

@interface EOCPerson (Work)
-(void)performDaysWork;
-(void)takeVacationFromWork; 
@end

@interface EOCPerson (Play)
-(void)goToTheCinema;
-(void)goToSportsGame;
@end

现在,类的实现代码按照方法分成了好几个部分。所以说,这项语言特性当然就叫做“分类”啦。

但是这些代码还是在一个文件中声明的,所以我们还可以将其拆分为多个文件:

  • EOCPerson+Friendship(.h/.m)
  • EOCPerson+Work(.h/.m)
  • EOCPerson+Play(.h/.m)

比方说,与交友功能相关的那个分类可以这样写:

// EOCPerson+Friendship.h
#import "EOCPerson.h"
@interface EOCPerson (Friendship)
-(void)addFriend:(EOCPerson*)person;
-(void)removeFriend:(EOCPerson*)person;
-(BOOL)isFriendsWith:(EOCPerson*)person;
@end

// EOCPerson+Friendship.m 

#import EOCPerson+Friendship.h
@implementation EOCPerson (Friendship)
-(void)addFriend:(EOCPerson*)person {
    /*...*/
}
-(void)removeFriend:(EOCPerson*)person {
    /*...*/
}
-(BOOL)isFriendsWith:(EOCPerson*)person {
    /*...*/
}
@end

通过分类机制,可以把类代码分成很多个易于管理的小块,以便单独检视。使用分类机制之后,如果想用分类中的方法,那么要记得在引入EOCPerson.h时一并引入分类的头文件

这样使用分类之后,对于某个分类中的所有 方法来说,分类名称都会出现在其符号中。例如,“addFriend:”方法的“符号名”(symbol name)如下:

-[EOCPerson(Friendship) addFriend:]

也可以创建名为Private的分类把这种方法全都放在里面。这个分类里的方法一般只会在类或框架内部使用,而无须对外公布。这样一来,类的使用者有时可能会在査看回溯信息时发现private一词,就知道不应该直接调用此方法了。

要点

  • 使用分类机制把类的实现代码划分成易于管理的小块。
  • 将应该视为“私有”的方法归入名叫Private的分类中,以隐藏实现细节。
2017/8/31 posted in  第四章 协议与分类

第23条:通过委托与数据源协议进行对象间通信

Objective-C语言有一项特性叫做“协议”(protocol),它与Java的“接口"(interface)类似Objective-C不支持多重继承,因而我们把某个类应该实现的一系列方法定义在协议里面。协议最为常见的用途是实现委托模式,不过也有其他用法。理解并善用协议可令代码变得更易维护,因为协议这种方式能很好地描述接口。

“分类”(Category)也是Objective-C的一项重要语言特性。利用分类机制,我们无须继承子类即可直接为当前类添加方法,而在其他编程语言中,则需通过继承子类来实现。由于 Objective-C运行期系统是髙度动态的,所以才能支持这一特性,然而,其中也隐藏着一些陷阱,因此在使用分类之前,应该先理解它。

OC中的通信方式有很多种,我们经常使用一种叫做“委托模式”(Delegate pattem)的编程设计模式来实现对象间的通信,该模式的主旨是: 定义一套接口,某对象若想接受另一个对象的委托,则需遵从此接口,以便成为其“委托对象”(delegate)。而这“另一个对象”则可以给其委托对象回传一些信息,也可以在发生相关事件时通知委托对象。

此模式可将数据与业务逻辑解耦。比方说,用户界面里有个显示一系列数据所用的视图,那么,此视图只应包含显示数据所需的逻辑代码,而不应决定要显示何种数据以及数据之间如何交互等问题。视图对象的属性中,可以包含负责数据与事件处理的对象。这两种对象分别称为“数据源"(data source)与“委托”(delegate)

我们来举个假设要编写一个从网上获取数据的类。此类也许要从远程服务器的某个资源里获取数据。那个远程服务器可能过很长时间才会应答,而在获取数据的过程中阻塞应用程序则是一种非常糟糕的做法。于是,在这种情况下,我们通常会使用委托模式:获取网络数据的类含有一个“委托对象”,在获取完数据之后,它会回调这个委托对象。

EOCDataModel对象就是EOCNetworkFetcher的委托对象。EOCDataModel请求EOCNetworkFetcher "以异步方式执行一项任务"(perform a task asynchronously),EOCNetworkFetcher在执行完这项任务之后,就会通知其委托对象,也就是EOCDataModel

利用协议机制,很容易就能以Objective-C代码实现此模式。在图4-1所演示的这种情况 下,协议可以这样来定义:

@protocol EOCNetworkFetcherDelegate 
-(void)networkFetcher:(EOCNetworkFetcher*)fetcher 
        didReceiveData:(NSData*)data;
-(void)networkFetcher:(EOCNetworkFetcher*)fetcher 
     didFailWithError:(NSError*)error;
@end

委托协议名通常是在相关类名后面加上Delegate一词,整个类名采用“驼峰法”来写。 以这种方式来命名委托协议的话,使用此代码的人很快就能理解其含义了。

然后我们要在这个EOCNetworkFetcher中设置一个属性来存放其委托对象。接口可以写成这样:

@interface EOCNetworkFetcher : NSObject 
@property (nonatomic, weak) id<EOCNetworkFetcherDelegate> delegate; 

一定要注意:这个属性需定义成weak,而非strong,因为两者之间必须为“非拥有关系” (nonowning relationship)。通常情况下,扮演delegate的那个对象也要持有本对象。所以我们要用weak来声明一种非拥有关系来避免“保留环”。

实现委托对象的办法是声明某个类遵从委托协议,然后把协议中想实现的那些方法在类 里实现出来。某类若要遵从委托协议,可以在其接口中声明,也可以在“class-contimiation分类”中声明。如果要向外界公布此类实现了某协议,那么就在接口中声明,而如果这个协议是个委托协议的话,那么通常只会在类的内部使用。所以说,这种情况一般都是在“class-continuation分类”里声明的:

@implementation EOCDataModel () <EOCNetworkFetcherDelegate> 
@end
@implementation EOCDataModel
-(void)networkFetcher:(EOCNetworkFetcher*)fetcher 
        didReceiveData:(NSData*)data {
/* Handle data */
}
-(void)networkFetcher:(EOCNetworkFetcher*)fetcher 
        didFailWithError:(NSError*)error {
/* Handle error */
}
@and

之后要用委托对象来调用方法时,必须提前使用类型信息査询方法(参见第14条)判断这个委托对象能否响应相关选择子。以EOCNetworkFetcher为例,应该这样写:

NSData *data = /*data obtained from network */;
if ([_delegate respondsToSelector:
     @selector(networkFetcher:didReceiveData:)))
{ 
    [_delegate networkFetcher:self  didReceiveData:data];
}

但是当方法变多了,我们就会频繁的来检查委托对象是否能够相应选择子,其实这个操作检测一次就可以了,所以我们可以用“位段(bitfield)”数据类型将该方法响应能力缓存起来。

这是一项乏人问津的C语言特性,但在此处用起来却正合适。我们可以把结构体中某个字段所占用的二进制位个数设为特定的值。比如像这样:

struct data {
    unsigned int fieldA : 8; 
    unsigned int fieldB : 4; 
    unsigned int fieldC : 2; 
    unsigned int fieldD : 1;
};

在结构体中,fieldA位段将占用8个二进制位,fieldB占用4个,fieldC占用两个,fieldD占用1个。于是,fieldA可以表示0至255之间的值,而fieldD则可以表示0或1这两个值。 我们举例子来说的话就是:

@interface EOCNetworkFetcher ()     {
    struct {
        unsigned int didReceiveData :   1;
        unsigned int didFailWithError : 1;      
        unsigned int didUpdateProgressTo : 1;
        }_delegateFlags;

这个结构体用来缓存委托对象是否能响应特定的选择子。实现缓存功能所用的代码可以 写在delegate属性所对应的设置方法里:

-(void)setDelegate:(id<EOCNetworkFetcherDelegate>)delegate {
    _delegate = delegate;   
    
    _delegateFlags.didReceiveData  = 
        [delegate respondsToSelector:
              @selector(networkFetcher:didReceiveData:)]; 
    
    _delegateFlags.didFailWithError =
        [delegate respondsToSelector:
              @selector(networkFetcher:didFailWithError:)]; 

    _delegateFlags.didUpdateProgressTo =
        [delegate respondsToSelector:
              @selector(networkFetcher:didUpdateProgressTo:)];

}

这样的话,每次调用delegate的相关方法之前,就不用检测委托对象是否能响应给定的选择子了,而是直接查询结构体里的标志:

if (_delegateFlags.didUpdateProgressTo) {
    [_delegate networkFetcher:self
          didUpdateProgressTo:currentProgress];
}

在相关方法要调用很多次时,值得进行这种优化。而是否需要优化,则应依照具体代码来定。这就需要分析代码性能,并找出瓶颈,若发现执行速度需要改进,则可使用此技巧。如果要频繁通过数据源协议从数据源中获取多份相互独立的数据,那么这项优化技术极有可能会提高程序效率.

要点

  • 委托模式为对象提供了一套接口,使其可由此将相关事件告知其他对象。
  • 将委托对象应该支持的接口定义成协议,在协议中把可能需要处理的事件定义成方法。
  • 当某对象需要从另外一个对象中获取数据时,可以使用委托模式。这种情境下,该模式亦称“数据源协议”(data source protocal)。
  • 若有必要,可实现含有位段的结构体,将委托对象是否能响应相关协议方法这一信息 缓存至其中。
2017/8/30 posted in  第四章 协议与分类

第二十二条 理解NSCopying协议

使用对象时经常需要拷贝它。在Objective-C中,此操作通过copy方法完成。如果想令自己的类支持拷贝操作,那就要实现NSCopying协议,该协议只有一个方法:

-(id)copyWithZone:(NSZone*)zone

为何会出现NSZone呢?因为以前开发程序时,会据此把内存分成不同的“区”(zone), 而对象会创建在某个区里面。现在不用了,每个程序只有一个区:“默认区”(default zone)。 所以说,尽管必须实现这个方法,但是你不必担心其中的zone参数。

copy方法由NSObject实现,该方法只是以“默认区”为参数来调用“copyWithZone:”。 我们总是想覆写copy方法,其实真正需要实现的却是“copyWithZone:”方法。这里我们一定要注意。

若想使某个类支持拷贝功能,只需声明该类遵从NSCopying协议,并实现其中的那个方法即可。比方说,有个表示个人信息的类,可以在其接口定义中声明此类遵从 NSCopying 协议:

#import <Foundation/Foundation.h>
@interface EOCPerson : NSObject <NSCopying>
@property (nonatomic, copy, readonly) NSString *firstName;
@property (nonatomic, copy, readonly) NSString *lastName;
-(id)initWithFirstName:(NSString*)firstName
          andLastName: (NSString*)lastName;

@end

然后,实现协议中规定的方法:

-(id)copyWithZone:(NSZone*)zone {
    EOCPerson *copy = [[[self class] allocWithZone:zone]
                     initWithFirstName :_firstName
                            andLastName:_lastName];
    return copy;
}

当然我们又是也要考虑具体情况,除了要拷贝对象,还要完成其他一些操作,比如类对象中的数据结构可能并未在初始化方法中设置好,需要另行设置。

#import <Foundation/Foundation.h>
@interface EOCPerson : NSObject<NSCopying>
@property (nonatomic, copy, readonly) NSString *firstName; 
@property (nonatomic, copy, readonly) NSString *lastName;
-(id)initWithFirstName: (NSString*) firstName
            andLastName:(NSString*)lastName;
-(void)addFriend:(EOCPerson*)person;
-(void)removeFriend:(EOCPerson*)person;

@end

@implementation EOCPerson {
    NSMutableSet *_friends;
)
- (id)initWithFirstName: (NSString*) firstName
             andLastName:(NSString*)lastName { 
    if ((self = [super init])) {
    _firstName = [firstName copy];
    _lastName = [lastName copy];
    _friends = [NSMutableSet newJ;
    }
    return self;

}
-(void)addFriend:(EOCPerson*)person {
    [_friends addObject:person];
}
-(void)removeFriend:(EOCPerson*)person {
    [_friends removeObject:person];
}
-(id)copyWithZone:(NSZone*)zone {
    EOCPerson *copy =[[[self class] allocWithZone:zone]
                        initWithFirstName: _firstName
                        andLastName:_lastName]; 
    copy->_friends = [_friends mutableCopy]; 
    return copy;
}
@end

这次所实现的方法比原来多了一些代码,它把本对象的_friends实例变量复制了一份, 令copy对象的_frieiids实例变量指向这个复制过的set。注意,这里使用了->语法,因为_friends并非属性,只是个在内部使用的实例变量。其实也可以声明一个属性来表示它,不过由于该变量不会在本类之外使用,所以那么做没必要。

我们在上面发现了一个mutableCopy方法,此方法来自另一个叫做NSMutableCopying的协议。该协议与NSCopying类似,也只定义了一个方法,然而方法名不同:

- (id)mutableCopyWithZone:(NSZone*)zone

mutableCopy这个“辅助方法”(helper)与copy相似,也是用默认的zone参数来调“mutableCopyWithZone:”。如果你的类分为可变版本(mutable variant)与不可变版本 (immutable variant),那么就应该实现NSMutableCopying。若采用此模式,则在可变类中覆写“copyWithZone:”方法时,不要返回可变的拷贝,而应返回一份不可变的版本。无论当前实例是否可变,若需获取其可变版本的拷贝,均应调用mutableCopy方法。同理,若需要不可变的拷贝,则总应通过copy方法来获取。

对于不可变的NSArray与可变的NSMutableArray来说,下列关系总是成立的:

-[NSMutableArray copy] =>NSArray
-[NSArray mutableCopy】 =>NSMutableArray

所谓我们会发现:在可变对象上调用copy方法会返冋另外一个不可变类的实例。这样做是为了能在可变版本与不可变版本之间自由切换。

浅拷贝与深拷贝

在编写拷贝方法时,还要决定一个问题,就是应该执行“深拷贝”(deep copy)还是“浅拷贝”(shallow copy)深拷贝的意思就是:在拷贝对象自身时,将其底层数据也一并复制过 去。Foundation框架中的所有collection类在默认情况下都执行浅拷贝,也就是说,只拷贝容器对象本身,而不复制其中数据。这样做的主要原因在于,容器内的对象未必都能拷贝,而且调用者也未必想在拷贝容器时一并拷贝其中的每个对象

一般情况下,我们会遵照系统框架所使用的那种模式,在自定义的类中以浅拷贝的方式实现“copyWithZone:”方法。但如果有必要的话,也可以增加一个执行深拷贝的方法。以 NSSet为例,该类提供了下面这个初始化方法,用以执行深拷贝:

-(id)initWithSet:(NSArray*)array copyltems:(BOOL)copyltems

copyltem参数设为YES,则该方法会向数组中的每个元素发送copy消息,用拷贝好的元素创建新的set,并将其返回给调用者。
EOCPerson那个例子中,存放朋友对象的set是用“ copyWithZone:”方法来拷贝的, 根据刚才讲的内容可知,这种浅拷贝方式不会逐个复制set中的元素。若需要深拷贝的话, 则可像下面这样,编写一个专供深拷贝所用的方法:

-(id)deepCopy {
    EOCPerson *copy =[[[self class] alloc]
                initWithFirstName:_firstName
                      andLastName:_lastName];               
    copy->_friends = [[NSMutableSet alloc] initWithSetfriends copyltems:YES];
    return copy;
}

因为没有专门定义深拷贝的协议,所以其具体执行方式由每个类来确定,你只需决定自 己所写的类是否要提供深拷贝方法即可。另外,不要假定遵从了 NSCopying协议的对象都会执行深拷贝。在绝大多数情况下,执行的都是浅拷贝。如果需要在某对象上执行深拷贝,那 么除非该类的文档说它是用深拷贝来实现NSCopying协议的,否则,要么寻找能够执行深拷贝的相关方法,要么自己编写方法来做。

要点

  • 若想令自己所写的对象具有拷贝功能,则需实现NSCopying协议。
  • 如果自定义的对象分为可变版本与不可变版本,那么就要同时实现NSCopyingNSMutableCopying 协议。
  • 复制对象时需决定采用浅拷贝还是深拷贝,一般情况下应该尽量执行浅拷贝。
  • 如果你所写的对象需要深拷贝,那么可考虑新增一个专门执行深拷贝的方法。
2017/8/29 posted in  第三章 接口与API设计

第二十一条 理解Objective-C的错误模型

Objective-C语言不例外的也有“异常”(exception)机制,但是与其它语言肯定存在差异。我们要重新学习一下。

首先就是,“自动引用计数”(Automatic ReferenceCounting, ARC)在默认情况下不是“异常安全的"(exception safe)。具体来说,这意味着:如果抛出异常,那么本应在作用域末尾释放的对象现在却不会自动释放了。如果想生成“异常安全”的代码,可以通过设置编译器的标志来实现,不过这将引入一些额外代码,在不抛出异常时,也照样要执行这部分代码。需要打开的编译器标志叫做-fobjc-arc-exceptions

但是我们应该注意,Objective-C语言只有在极其罕见的情况下拋出异常,异常拋出之后,无须考虑恢复问题,而且应用程序此时也应该退出。这就是说,不用再编写复杂的“异常安全”代码了。

异常只应该用于极其严重的错误,比如说,你编写了某个抽象基类,它的正确用法是先从中继承一个子类,然后使用这个子类。在这种情况下,如果有人直接使用了这个抽象基类,那么可以考虑抛出异常。

与其他语言不同,Objective-C中没办法将某个类标识为“抽象 类”。要想达成类似效果,最好的办法是在那些子类必须覆写的超类方法里抛出异常。这样的话,只要有人直接创建抽象基类的实例并使用它,即会拋出异常:

-(void)mustOverrideMethod {
NSString *reason = [NSStringstringWithFormat: 
                    @"%@ must be overridden",
                    NSStringFromSelector(_cmd)];
@throw [NSException
    exceptionWithName:NSInternalInconsistencyException 
    reason:reason 
    userInfo:nil];
}

既然异常只用于处理严重错误(fatal error,致命错误),那么对其他错误怎么办呢?在出 现“不那么严重的错误"(nonfatal error,非致命错误)时,Objective-C语言所用的编程范式为: 令方法返回nil/0,或是使用NSError,以表明其中有错误发生。例如,如果初始化方法无法根据传入的参数来初始化当前实例,那么就可以令其返回nil/0:

-(id)initWithValue:(id)value { 
    if ((self = [super init])){
        if ( /* Value means instance can11 be created */ ) { 
        self = nil;
     } else {
        // Initialize instance
        }
     }
    return self;
}

在这种情况下,如果if语句发现无法用传人的参数值来初始化当前实例(比如这个方法 要求传入的value参数必须是non-nil的),那么就把self设置成nil,这样的话,整个方法的 返回值也就是nil了。调用者发现初始化方法并没有把实例创建好,于是便可确定其中发生了错误。

NSError的用法更加灵活,因为经由此对象,我们可以把导致错误的原因回报给调用者。 NSError对象里封装了三条信息:

  • Error domain(错误范围,其类型为字符串)
    错误发生的范围。也就是产生错误的根源,通常用一个特有的全局变量来定义。比方说,“处理URL的子系统”(URL-handling subsystem)在从URL中解析或取得数据时如果出错了,那么就会使用NSURLErrorDomain来表示错误范围。

  • Error code(错误码,其类型为整数)
    独有的错误代码,用以指明在某个范围内具体发生了何种错误。某个特定范围内可能会发生一系列相关错误,这些错误情况通常采用enum来定义。例如,当HTTP请求出错时,可能会把HTTP状态码设为错误码。

  • Uesr info(用户信息,其类型为字典)
    有关此错误的额外信息,其中或许包含一段“本地化的描述”(localized description), 或许还含有导致该错误发生的另外一个错误,经由此种信息,可将相关错误串成一条 “错误链”(chain of errors)

NSError的一种常见用法是,经由方法的“输出参数”返回给调用者。比如像这样:

-(BOOL)doSomething: (NSError**)error

用例为:

NSError *error = nil;
BOOL ret = [object doSomething:&error];
    if (error) {
//There was an error
}

也可以通过委托协议来传递此错误。有错误发生时,当前对象会把错误信息经由协议中的某个方法传给其委托对象(delegate)。这里不做过多说明。

要点

  • 只有发生了可使整个应用程序崩溃的严重错误时,才应使用异常。
  • 在错误不那么严重的情况下,可以指派“委托方法”(delegate method)来处理错误,也可以把错误信息放在NSError对象里,经由“输出参数”返回给调用者。
2017/8/28 posted in  第三章 接口与API设计